home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / ftplib.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  19KB  |  838 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import os
  5. import sys
  6.  
  7. try:
  8.     import SOCKS
  9.     socket = SOCKS
  10.     del SOCKS
  11.     from socket import getfqdn
  12.     socket.getfqdn = getfqdn
  13.     del getfqdn
  14. except ImportError:
  15.     import socket
  16.  
  17. __all__ = [
  18.     'FTP',
  19.     'Netrc']
  20. MSG_OOB = 1
  21. FTP_PORT = 21
  22.  
  23. class Error(Exception):
  24.     pass
  25.  
  26.  
  27. class error_reply(Error):
  28.     pass
  29.  
  30.  
  31. class error_temp(Error):
  32.     pass
  33.  
  34.  
  35. class error_perm(Error):
  36.     pass
  37.  
  38.  
  39. class error_proto(Error):
  40.     pass
  41.  
  42. all_errors = (Error, socket.error, IOError, EOFError)
  43. CRLF = '\r\n'
  44.  
  45. class FTP:
  46.     debugging = 0
  47.     host = ''
  48.     port = FTP_PORT
  49.     sock = None
  50.     file = None
  51.     welcome = None
  52.     passiveserver = 1
  53.     
  54.     def __init__(self, host = '', user = '', passwd = '', acct = ''):
  55.         if host:
  56.             self.connect(host)
  57.             if user:
  58.                 self.login(user, passwd, acct)
  59.             
  60.         
  61.  
  62.     
  63.     def connect(self, host = '', port = 0):
  64.         if host:
  65.             self.host = host
  66.         
  67.         if port:
  68.             self.port = port
  69.         
  70.         msg = 'getaddrinfo returns an empty list'
  71.         for res in socket.getaddrinfo(self.host, self.port, 0, socket.SOCK_STREAM):
  72.             (af, socktype, proto, canonname, sa) = res
  73.             
  74.             try:
  75.                 self.sock = socket.socket(af, socktype, proto)
  76.                 self.sock.connect(sa)
  77.             except socket.error:
  78.                 msg = None
  79.                 if self.sock:
  80.                     self.sock.close()
  81.                 
  82.                 self.sock = None
  83.                 continue
  84.  
  85.             break
  86.         
  87.         if not self.sock:
  88.             raise socket.error, msg
  89.         
  90.         self.af = af
  91.         self.file = self.sock.makefile('rb')
  92.         self.welcome = self.getresp()
  93.         return self.welcome
  94.  
  95.     
  96.     def getwelcome(self):
  97.         if self.debugging:
  98.             print '*welcome*', self.sanitize(self.welcome)
  99.         
  100.         return self.welcome
  101.  
  102.     
  103.     def set_debuglevel(self, level):
  104.         self.debugging = level
  105.  
  106.     debug = set_debuglevel
  107.     
  108.     def set_pasv(self, val):
  109.         self.passiveserver = val
  110.  
  111.     
  112.     def sanitize(self, s):
  113.         if s[:5] == 'pass ' or s[:5] == 'PASS ':
  114.             i = len(s)
  115.             while i > 5 and s[i - 1] in '\r\n':
  116.                 i = i - 1
  117.             s = s[:5] + '*' * (i - 5) + s[i:]
  118.         
  119.         return repr(s)
  120.  
  121.     
  122.     def putline(self, line):
  123.         line = line + CRLF
  124.         if self.debugging > 1:
  125.             print '*put*', self.sanitize(line)
  126.         
  127.         self.sock.sendall(line)
  128.  
  129.     
  130.     def putcmd(self, line):
  131.         if self.debugging:
  132.             print '*cmd*', self.sanitize(line)
  133.         
  134.         self.putline(line)
  135.  
  136.     
  137.     def getline(self):
  138.         line = self.file.readline()
  139.         if self.debugging > 1:
  140.             print '*get*', self.sanitize(line)
  141.         
  142.         if not line:
  143.             raise EOFError
  144.         
  145.         if line[-2:] == CRLF:
  146.             line = line[:-2]
  147.         elif line[-1:] in CRLF:
  148.             line = line[:-1]
  149.         
  150.         return line
  151.  
  152.     
  153.     def getmultiline(self):
  154.         line = self.getline()
  155.         if line[3:4] == '-':
  156.             code = line[:3]
  157.             while None:
  158.                 nextline = self.getline()
  159.                 line = line + '\n' + nextline
  160.                 if nextline[:3] == code and nextline[3:4] != '-':
  161.                     break
  162.                     continue
  163.                 continue
  164.         line[3:4] == '-'
  165.         return line
  166.  
  167.     
  168.     def getresp(self):
  169.         resp = self.getmultiline()
  170.         if self.debugging:
  171.             print '*resp*', self.sanitize(resp)
  172.         
  173.         self.lastresp = resp[:3]
  174.         c = resp[:1]
  175.         if c in ('1', '2', '3'):
  176.             return resp
  177.         
  178.         if c == '4':
  179.             raise error_temp, resp
  180.         
  181.         if c == '5':
  182.             raise error_perm, resp
  183.         
  184.         raise error_proto, resp
  185.  
  186.     
  187.     def voidresp(self):
  188.         resp = self.getresp()
  189.         if resp[0] != '2':
  190.             raise error_reply, resp
  191.         
  192.         return resp
  193.  
  194.     
  195.     def abort(self):
  196.         line = 'ABOR' + CRLF
  197.         if self.debugging > 1:
  198.             print '*put urgent*', self.sanitize(line)
  199.         
  200.         self.sock.sendall(line, MSG_OOB)
  201.         resp = self.getmultiline()
  202.         if resp[:3] not in ('426', '226'):
  203.             raise error_proto, resp
  204.         
  205.  
  206.     
  207.     def sendcmd(self, cmd):
  208.         self.putcmd(cmd)
  209.         return self.getresp()
  210.  
  211.     
  212.     def voidcmd(self, cmd):
  213.         self.putcmd(cmd)
  214.         return self.voidresp()
  215.  
  216.     
  217.     def sendport(self, host, port):
  218.         hbytes = host.split('.')
  219.         pbytes = [
  220.             repr(port / 256),
  221.             repr(port % 256)]
  222.         bytes = hbytes + pbytes
  223.         cmd = 'PORT ' + ','.join(bytes)
  224.         return self.voidcmd(cmd)
  225.  
  226.     
  227.     def sendeprt(self, host, port):
  228.         af = 0
  229.         if self.af == socket.AF_INET:
  230.             af = 1
  231.         
  232.         if self.af == socket.AF_INET6:
  233.             af = 2
  234.         
  235.         if af == 0:
  236.             raise error_proto, 'unsupported address family'
  237.         
  238.         fields = [
  239.             '',
  240.             repr(af),
  241.             host,
  242.             repr(port),
  243.             '']
  244.         cmd = 'EPRT ' + '|'.join(fields)
  245.         return self.voidcmd(cmd)
  246.  
  247.     
  248.     def makeport(self):
  249.         msg = 'getaddrinfo returns an empty list'
  250.         sock = None
  251.         for res in socket.getaddrinfo(None, 0, self.af, socket.SOCK_STREAM, 0, socket.AI_PASSIVE):
  252.             (af, socktype, proto, canonname, sa) = res
  253.             
  254.             try:
  255.                 sock = socket.socket(af, socktype, proto)
  256.                 sock.bind(sa)
  257.             except socket.error:
  258.                 msg = None
  259.                 if sock:
  260.                     sock.close()
  261.                 
  262.                 sock = None
  263.                 continue
  264.  
  265.             break
  266.         
  267.         if not sock:
  268.             raise socket.error, msg
  269.         
  270.         sock.listen(1)
  271.         port = sock.getsockname()[1]
  272.         host = self.sock.getsockname()[0]
  273.         if self.af == socket.AF_INET:
  274.             resp = self.sendport(host, port)
  275.         else:
  276.             resp = self.sendeprt(host, port)
  277.         return sock
  278.  
  279.     
  280.     def makepasv(self):
  281.         if self.af == socket.AF_INET:
  282.             (host, port) = parse227(self.sendcmd('PASV'))
  283.         else:
  284.             (host, port) = parse229(self.sendcmd('EPSV'), self.sock.getpeername())
  285.         return (host, port)
  286.  
  287.     
  288.     def ntransfercmd(self, cmd, rest = None):
  289.         size = None
  290.         if self.passiveserver:
  291.             (host, port) = self.makepasv()
  292.             (af, socktype, proto, canon, sa) = socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM)[0]
  293.             conn = socket.socket(af, socktype, proto)
  294.             conn.connect(sa)
  295.             if rest is not None:
  296.                 self.sendcmd('REST %s' % rest)
  297.             
  298.             resp = self.sendcmd(cmd)
  299.             if resp[0] == '2':
  300.                 resp = self.getresp()
  301.             
  302.             if resp[0] != '1':
  303.                 raise error_reply, resp
  304.             
  305.         else:
  306.             sock = self.makeport()
  307.             if rest is not None:
  308.                 self.sendcmd('REST %s' % rest)
  309.             
  310.             resp = self.sendcmd(cmd)
  311.             if resp[0] == '2':
  312.                 resp = self.getresp()
  313.             
  314.             if resp[0] != '1':
  315.                 raise error_reply, resp
  316.             
  317.             (conn, sockaddr) = sock.accept()
  318.         if resp[:3] == '150':
  319.             size = parse150(resp)
  320.         
  321.         return (conn, size)
  322.  
  323.     
  324.     def transfercmd(self, cmd, rest = None):
  325.         return self.ntransfercmd(cmd, rest)[0]
  326.  
  327.     
  328.     def login(self, user = '', passwd = '', acct = ''):
  329.         if not user:
  330.             user = 'anonymous'
  331.         
  332.         if not passwd:
  333.             passwd = ''
  334.         
  335.         if not acct:
  336.             acct = ''
  337.         
  338.         if user == 'anonymous' and passwd in ('', '-'):
  339.             passwd = passwd + 'anonymous@'
  340.         
  341.         resp = self.sendcmd('USER ' + user)
  342.         if resp[0] == '3':
  343.             resp = self.sendcmd('PASS ' + passwd)
  344.         
  345.         if resp[0] == '3':
  346.             resp = self.sendcmd('ACCT ' + acct)
  347.         
  348.         if resp[0] != '2':
  349.             raise error_reply, resp
  350.         
  351.         return resp
  352.  
  353.     
  354.     def retrbinary(self, cmd, callback, blocksize = 8192, rest = None):
  355.         self.voidcmd('TYPE I')
  356.         conn = self.transfercmd(cmd, rest)
  357.         while None:
  358.             data = conn.recv(blocksize)
  359.             if not data:
  360.                 break
  361.             
  362.             continue
  363.             conn.close()
  364.             return self.voidresp()
  365.  
  366.     
  367.     def retrlines(self, cmd, callback = None):
  368.         if callback is None:
  369.             callback = print_line
  370.         
  371.         resp = self.sendcmd('TYPE A')
  372.         conn = self.transfercmd(cmd)
  373.         fp = conn.makefile('rb')
  374.         while None:
  375.             line = fp.readline()
  376.             if self.debugging > 2:
  377.                 print '*retr*', repr(line)
  378.             
  379.             if not line:
  380.                 break
  381.             
  382.             if line[-2:] == CRLF:
  383.                 line = line[:-2]
  384.             elif line[-1:] == '\n':
  385.                 line = line[:-1]
  386.             
  387.             continue
  388.             fp.close()
  389.             conn.close()
  390.             return self.voidresp()
  391.  
  392.     
  393.     def storbinary(self, cmd, fp, blocksize = 8192):
  394.         self.voidcmd('TYPE I')
  395.         conn = self.transfercmd(cmd)
  396.         while None:
  397.             buf = fp.read(blocksize)
  398.             if not buf:
  399.                 break
  400.             
  401.             continue
  402.             conn.close()
  403.             return self.voidresp()
  404.  
  405.     
  406.     def storlines(self, cmd, fp):
  407.         self.voidcmd('TYPE A')
  408.         conn = self.transfercmd(cmd)
  409.         while None:
  410.             buf = fp.readline()
  411.             if not buf:
  412.                 break
  413.             
  414.             if buf[-2:] != CRLF:
  415.                 if buf[-1] in CRLF:
  416.                     buf = buf[:-1]
  417.                 
  418.                 buf = buf + CRLF
  419.             
  420.             continue
  421.             conn.close()
  422.             return self.voidresp()
  423.  
  424.     
  425.     def acct(self, password):
  426.         cmd = 'ACCT ' + password
  427.         return self.voidcmd(cmd)
  428.  
  429.     
  430.     def nlst(self, *args):
  431.         cmd = 'NLST'
  432.         for arg in args:
  433.             cmd = cmd + ' ' + arg
  434.         
  435.         files = []
  436.         self.retrlines(cmd, files.append)
  437.         return files
  438.  
  439.     
  440.     def dir(self, *args):
  441.         cmd = 'LIST'
  442.         func = None
  443.         if args[-1:] and type(args[-1]) != type(''):
  444.             args = args[:-1]
  445.             func = args[-1]
  446.         
  447.         for arg in args:
  448.             if arg:
  449.                 cmd = cmd + ' ' + arg
  450.                 continue
  451.         
  452.         self.retrlines(cmd, func)
  453.  
  454.     
  455.     def rename(self, fromname, toname):
  456.         resp = self.sendcmd('RNFR ' + fromname)
  457.         if resp[0] != '3':
  458.             raise error_reply, resp
  459.         
  460.         return self.voidcmd('RNTO ' + toname)
  461.  
  462.     
  463.     def delete(self, filename):
  464.         resp = self.sendcmd('DELE ' + filename)
  465.         if resp[:3] in ('250', '200'):
  466.             return resp
  467.         elif resp[:1] == '5':
  468.             raise error_perm, resp
  469.         else:
  470.             raise error_reply, resp
  471.  
  472.     
  473.     def cwd(self, dirname):
  474.         if dirname == '..':
  475.             
  476.             try:
  477.                 return self.voidcmd('CDUP')
  478.             except error_perm:
  479.                 msg = None
  480.                 if msg.args[0][:3] != '500':
  481.                     raise 
  482.                 
  483.             except:
  484.                 msg.args[0][:3] != '500'
  485.             
  486.  
  487.         None<EXCEPTION MATCH>error_perm
  488.         if dirname == '':
  489.             dirname = '.'
  490.         
  491.         cmd = 'CWD ' + dirname
  492.         return self.voidcmd(cmd)
  493.  
  494.     
  495.     def size(self, filename):
  496.         resp = self.sendcmd('SIZE ' + filename)
  497.         if resp[:3] == '213':
  498.             s = resp[3:].strip()
  499.             
  500.             try:
  501.                 return int(s)
  502.             except (OverflowError, ValueError):
  503.                 return long(s)
  504.             except:
  505.                 None<EXCEPTION MATCH>(OverflowError, ValueError)
  506.             
  507.  
  508.         None<EXCEPTION MATCH>(OverflowError, ValueError)
  509.  
  510.     
  511.     def mkd(self, dirname):
  512.         resp = self.sendcmd('MKD ' + dirname)
  513.         return parse257(resp)
  514.  
  515.     
  516.     def rmd(self, dirname):
  517.         return self.voidcmd('RMD ' + dirname)
  518.  
  519.     
  520.     def pwd(self):
  521.         resp = self.sendcmd('PWD')
  522.         return parse257(resp)
  523.  
  524.     
  525.     def quit(self):
  526.         resp = self.voidcmd('QUIT')
  527.         self.close()
  528.         return resp
  529.  
  530.     
  531.     def close(self):
  532.         if self.file:
  533.             self.file.close()
  534.             self.sock.close()
  535.             self.file = None
  536.             self.sock = None
  537.         
  538.  
  539.  
  540. _150_re = None
  541.  
  542. def parse150(resp):
  543.     global _150_re
  544.     if resp[:3] != '150':
  545.         raise error_reply, resp
  546.     
  547.     if _150_re is None:
  548.         import re as re
  549.         _150_re = re.compile('150 .* \\((\\d+) bytes\\)', re.IGNORECASE)
  550.     
  551.     m = _150_re.match(resp)
  552.     if not m:
  553.         return None
  554.     
  555.     s = m.group(1)
  556.     
  557.     try:
  558.         return int(s)
  559.     except (OverflowError, ValueError):
  560.         return long(s)
  561.  
  562.  
  563. _227_re = None
  564.  
  565. def parse227(resp):
  566.     global _227_re
  567.     if resp[:3] != '227':
  568.         raise error_reply, resp
  569.     
  570.     if _227_re is None:
  571.         import re
  572.         _227_re = re.compile('(\\d+),(\\d+),(\\d+),(\\d+),(\\d+),(\\d+)')
  573.     
  574.     m = _227_re.search(resp)
  575.     if not m:
  576.         raise error_proto, resp
  577.     
  578.     numbers = m.groups()
  579.     host = '.'.join(numbers[:4])
  580.     port = (int(numbers[4]) << 8) + int(numbers[5])
  581.     return (host, port)
  582.  
  583.  
  584. def parse229(resp, peer):
  585.     if resp[:3] != '229':
  586.         raise error_reply, resp
  587.     
  588.     left = resp.find('(')
  589.     if left < 0:
  590.         raise error_proto, resp
  591.     
  592.     right = resp.find(')', left + 1)
  593.     if right < 0:
  594.         raise error_proto, resp
  595.     
  596.     if resp[left + 1] != resp[right - 1]:
  597.         raise error_proto, resp
  598.     
  599.     parts = resp[left + 1:right].split(resp[left + 1])
  600.     if len(parts) != 5:
  601.         raise error_proto, resp
  602.     
  603.     host = peer[0]
  604.     port = int(parts[3])
  605.     return (host, port)
  606.  
  607.  
  608. def parse257(resp):
  609.     if resp[:3] != '257':
  610.         raise error_reply, resp
  611.     
  612.     if resp[3:5] != ' "':
  613.         return ''
  614.     
  615.     dirname = ''
  616.     i = 5
  617.     n = len(resp)
  618.     while i < n:
  619.         c = resp[i]
  620.         i = i + 1
  621.         if c == '"':
  622.             if i >= n or resp[i] != '"':
  623.                 break
  624.             
  625.             i = i + 1
  626.         
  627.         dirname = dirname + c
  628.     return dirname
  629.  
  630.  
  631. def print_line(line):
  632.     print line
  633.  
  634.  
  635. def ftpcp(source, sourcename, target, targetname = '', type = 'I'):
  636.     if not targetname:
  637.         targetname = sourcename
  638.     
  639.     type = 'TYPE ' + type
  640.     source.voidcmd(type)
  641.     target.voidcmd(type)
  642.     (sourcehost, sourceport) = parse227(source.sendcmd('PASV'))
  643.     target.sendport(sourcehost, sourceport)
  644.     treply = target.sendcmd('STOR ' + targetname)
  645.     if treply[:3] not in ('125', '150'):
  646.         raise error_proto
  647.     
  648.     sreply = source.sendcmd('RETR ' + sourcename)
  649.     if sreply[:3] not in ('125', '150'):
  650.         raise error_proto
  651.     
  652.     source.voidresp()
  653.     target.voidresp()
  654.  
  655.  
  656. class Netrc:
  657.     __defuser = None
  658.     __defpasswd = None
  659.     __defacct = None
  660.     
  661.     def __init__(self, filename = None):
  662.         if filename is None:
  663.             if 'HOME' in os.environ:
  664.                 filename = os.path.join(os.environ['HOME'], '.netrc')
  665.             else:
  666.                 raise IOError, 'specify file to load or set $HOME'
  667.         
  668.         self._Netrc__hosts = { }
  669.         self._Netrc__macros = { }
  670.         fp = open(filename, 'r')
  671.         in_macro = 0
  672.         while None:
  673.             line = fp.readline()
  674.             if not line:
  675.                 break
  676.             
  677.             if in_macro and line.strip():
  678.                 macro_lines.append(line)
  679.                 continue
  680.             elif in_macro:
  681.                 self._Netrc__macros[macro_name] = tuple(macro_lines)
  682.                 in_macro = 0
  683.             
  684.             words = line.split()
  685.             host = None
  686.             user = None
  687.             passwd = None
  688.             acct = None
  689.             default = 0
  690.             i = 0
  691.             while i < len(words):
  692.                 w1 = words[i]
  693.                 if i + 1 < len(words):
  694.                     w2 = words[i + 1]
  695.                 else:
  696.                     w2 = None
  697.                 if w1 == 'default':
  698.                     default = 1
  699.                 elif w1 == 'machine' and w2:
  700.                     host = w2.lower()
  701.                     i = i + 1
  702.                 elif w1 == 'login' and w2:
  703.                     user = w2
  704.                     i = i + 1
  705.                 elif w1 == 'password' and w2:
  706.                     passwd = w2
  707.                     i = i + 1
  708.                 elif w1 == 'account' and w2:
  709.                     acct = w2
  710.                     i = i + 1
  711.                 elif w1 == 'macdef' and w2:
  712.                     macro_name = w2
  713.                     macro_lines = []
  714.                     in_macro = 1
  715.                     break
  716.                 
  717.                 i = i + 1
  718.             if default:
  719.                 if not user:
  720.                     pass
  721.                 self._Netrc__defuser = self._Netrc__defuser
  722.                 if not passwd:
  723.                     pass
  724.                 self._Netrc__defpasswd = self._Netrc__defpasswd
  725.                 if not acct:
  726.                     pass
  727.                 self._Netrc__defacct = self._Netrc__defacct
  728.             
  729.             if host:
  730.                 if host in self._Netrc__hosts:
  731.                     (ouser, opasswd, oacct) = self._Netrc__hosts[host]
  732.                     if not user:
  733.                         pass
  734.                     user = ouser
  735.                     if not passwd:
  736.                         pass
  737.                     passwd = opasswd
  738.                     if not acct:
  739.                         pass
  740.                     acct = oacct
  741.                 
  742.                 self._Netrc__hosts[host] = (user, passwd, acct)
  743.                 continue
  744.             continue
  745.             fp.close()
  746.             return None
  747.  
  748.     
  749.     def get_hosts(self):
  750.         return self._Netrc__hosts.keys()
  751.  
  752.     
  753.     def get_account(self, host):
  754.         host = host.lower()
  755.         user = None
  756.         passwd = None
  757.         acct = None
  758.         if host in self._Netrc__hosts:
  759.             (user, passwd, acct) = self._Netrc__hosts[host]
  760.         
  761.         if not user:
  762.             pass
  763.         user = self._Netrc__defuser
  764.         if not passwd:
  765.             pass
  766.         passwd = self._Netrc__defpasswd
  767.         if not acct:
  768.             pass
  769.         acct = self._Netrc__defacct
  770.         return (user, passwd, acct)
  771.  
  772.     
  773.     def get_macros(self):
  774.         return self._Netrc__macros.keys()
  775.  
  776.     
  777.     def get_macro(self, macro):
  778.         return self._Netrc__macros[macro]
  779.  
  780.  
  781.  
  782. def test():
  783.     if len(sys.argv) < 2:
  784.         print test.__doc__
  785.         sys.exit(0)
  786.     
  787.     debugging = 0
  788.     rcfile = None
  789.     while sys.argv[1] == '-d':
  790.         debugging = debugging + 1
  791.         del sys.argv[1]
  792.     if sys.argv[1][:2] == '-r':
  793.         rcfile = sys.argv[1][2:]
  794.         del sys.argv[1]
  795.     
  796.     host = sys.argv[1]
  797.     ftp = FTP(host)
  798.     ftp.set_debuglevel(debugging)
  799.     userid = passwd = acct = ''
  800.     
  801.     try:
  802.         netrc = Netrc(rcfile)
  803.     except IOError:
  804.         if rcfile is not None:
  805.             sys.stderr.write('Could not open account file -- using anonymous login.')
  806.         
  807.     except:
  808.         rcfile is not None
  809.  
  810.     
  811.     try:
  812.         (userid, passwd, acct) = netrc.get_account(host)
  813.     except KeyError:
  814.         sys.stderr.write('No account -- using anonymous login.')
  815.  
  816.     ftp.login(userid, passwd, acct)
  817.     for file in sys.argv[2:]:
  818.         if file[:2] == '-l':
  819.             ftp.dir(file[2:])
  820.             continue
  821.         if file[:2] == '-d':
  822.             cmd = 'CWD'
  823.             if file[2:]:
  824.                 cmd = cmd + ' ' + file[2:]
  825.             
  826.             resp = ftp.sendcmd(cmd)
  827.             continue
  828.         if file == '-p':
  829.             ftp.set_pasv(not (ftp.passiveserver))
  830.             continue
  831.         ftp.retrbinary('RETR ' + file, sys.stdout.write, 1024)
  832.     
  833.     ftp.quit()
  834.  
  835. if __name__ == '__main__':
  836.     test()
  837.  
  838.